37 research outputs found
On Constructing One-Way Permutations from Indistinguishability Obfuscation
We prove that there is no black-box construction of a one-way permutation family from a one-way function and an indistinguishability obfuscator for the class of all oracle-aided circuits, where the construction is domain invariant (i.e., where each permutation may have its own domain, but these domains are independent of the underlying building blocks).
Following the framework of Asharov and Segev (FOCS \u2715), by considering indistinguishability obfuscation for oracle-aided circuits we capture the common techniques that have been used so far in constructions based on indistinguishability obfuscation. These include, in particular, non-black-box techniques such as the punctured programming approach of Sahai and Waters (STOC \u2714) and its variants, as well as sub-exponential security assumptions. For example, we fully capture the construction of a trapdoor permutation family from a one-way function and an indistinguishability obfuscator due to Bitansky, Paneth and Wichs (TCC \u2716). Their construction is not domain invariant and our result shows that this, somewhat undesirable property, is unavoidable using the common techniques.
In fact, we observe that constructions which are not domain invariant circumvent all known negative results for constructing one-way permutations based on one-way functions, starting with Rudich\u27s seminal work (PhD thesis \u2788). We revisit this classic and fundamental problem, and resolve this somewhat surprising gap by ruling out all such black-box constructions -- even those that are not domain invariant
Gradecast in Synchrony and Reliable Broadcast in Asynchrony with Optimal Resilience, Efficiency, and Unconditional Security
We revisit Gradecast (Feldman and Micali, STOC\u2788) in Synchrony and Reliable Broadcast (Bracha, Information and Computation\u2787) in Asynchrony. For both tasks ,we provide new protocols that have three desirable properties: (1) \emph{optimal resilience}, tolerating malicious parties; (2) are \emph{communication-efficient}, where honest parties send just bits for a sender with a message of bits; (3) and are \emph{unconditionally secure}, without needing to rely on any computational or setup assumptions (while having a statistical error probability). To the best of our knowledge, no previous work obtains all three properties simultaneously
A Full Proof of the BGW Protocol for Perfectly-Secure Multiparty Computation
In the setting of secure multiparty computation, a set of parties with private inputs wish to jointly compute some functionality of their inputs. One of the most fundamental results of secure computation was presented by Ben-Or, Goldwasser and Wigderson (BGW) in 1988. They demonstrated that any -party functionality can be computed with \emph{perfect security}, in the private channels model. When the adversary is semi-honest this holds as long as parties are corrupted, and when the adversary is malicious this holds as long as parties are corrupted. Unfortunately, a full proof of these results was never published. In this paper, we remedy this situation and provide a full proof of security of the BGW protocol. This includes a full description of the protocol for the malicious setting, including the construction of a new subprotocol for the perfect multiplication protocol that seems necessary for the case of
Perfectly Secure Asynchronous Agreement on a Core Set in Constant Expected Time
A major challenge of any asynchronous MPC protocol is the need to reach agreement on the set of private inputs to be used as input for the MPC functionality. Ben-Or, Canetti and Goldreich [STOC 93] call this problem Agreement on a Core Set (ACS) and solve it by running parallel instances of asynchronous binary Byzantine agreements. To the best of our knowledge, all results in the perfect and statistical security setting used this same paradigm for solving ACS. This leads to a fundamental barrier of expected rounds for any asynchronous MPC protocol (even for constant depth circuits).
We provide a new solution for Agreement on a Core Set that runs in expected rounds, is perfectly secure, and resilient to corruptions. Our solution is based on a new notion of Asynchronously Validated Asynchronous Byzantine Agreement (AVABA) and new information theoretic analogs to techniques used in the authenticated model. We show a similar result with statistical security for
Tight Tradeoffs in Searchable Symmetric Encryption
A searchable symmetric encryption (SSE) scheme enables a client to store data on an untrusted server while supporting keyword searches in a secure manner. Recent experiments have indicated that the practical relevance of such schemes heavily relies on the tradeoff between their space overhead, locality (the number of non-contiguous memory locations that the server accesses with each query), and read efficiency (the ratio between the number of bits the server reads with each query and the actual size of the answer). These experiments motivated Cash and Tessaro (EUROCRYPT \u2714) and Asharov et al. (STOC \u2716) to construct SSE schemes offering various such tradeoffs, and to prove lower bounds for natural SSE frameworks. Unfortunately, the best-possible tradeoff has not been identified, and there are substantial gaps between the existing schemes and lower bounds, indicating that a better understanding of SSE is needed.
We establish tight bounds on the tradeoff between the space overhead, locality and read efficiency of SSE schemes within two general frameworks that capture the memory access pattern underlying all existing schemes. First, we introduce the ``pad-and-split\u27\u27 framework, refining that of Cash and Tessaro while still capturing the same existing schemes. Within our framework we significantly strengthen their lower bound, proving that any scheme with locality must use space for databases of size . This is a tight lower bound, matching the tradeoff provided by the scheme of Demertzis and Papamanthou (SIGMOD \u2717) which is captured by our pad-and-split framework.
Then, within the ``statistical-independence\u27\u27 framework of Asharov et al. we show that their lower bound is essentially tight: We construct a scheme whose tradeoff matches their lower bound within an additive factor in its read efficiency, once again improving upon the existing schemes. Our scheme offers optimal space and locality, and nearly-optimal read efficiency that depends on the frequency of the queried keywords: For a keyword that is associated with document identifiers, the read efficiency is when retrieving its identifiers (where the term may be arbitrarily small, and is the lower bound proved by Asharov et al.). In particular, for any keyword that is associated with at most document identifiers (i.e., for any keyword that is not exceptionally common), we provide read efficiency when retrieving its identifiers
Efficient Perfectly Secure Computation with Optimal Resilience
Secure computation enables mutually distrustful parties to compute a function over their private inputs jointly. In 1988 Ben-Or, Goldwasser, and Wigderson (BGW) demonstrated that any function can be computed with perfect security in the presence of a malicious adversary corrupting at most parties.
After more than 30 years, protocols with perfect malicious security, with round complexity proportional to the circuit\u27s depth, still require sharing a total of values per multiplication.
In contrast, only values need to be shared per multiplication to achieve semi-honest security. Indeed sharing values for a single multiplication seems to be the natural barrier for polynomial secret sharing-based multiplication.
In this paper, we close this gap by constructing a new secure computation protocol with perfect, optimal resilience and malicious security that incurs sharing of only values per multiplication, thus, matching the semi-honest setting for protocols with round complexity that is proportional to the circuit depth. Our protocol requires a constant number of rounds per multiplication. Like BGW, it has an overall round complexity that is proportional only to the multiplicative depth of the circuit.
Our improvement is obtained by a novel construction for {\em weak VSS for polynomials of degree-}, which incurs the same communication and round complexities as the state-of-the-art constructions for {\em VSS for polynomials of degree-}.
Our second contribution is a method for reducing the communication complexity for any depth-1 sub-circuit to be proportional only to the size of the input and output (rather than the size of the circuit). This implies protocols with \emph{sublinear communication complexity} (in the size of the circuit) for perfectly secure computation for important functions like matrix multiplication
FutORAMa: A Concretely Efficient Hierarchical Oblivious RAM
Oblivious RAM (ORAM) is a general-purpose technique for hiding memory access patterns. This is a fundamental task underlying many secure computation applications. While known ORAM schemes provide optimal asymptotic complexity, despite extensive efforts, their concrete costs remain prohibitively expensive for many interesting applications. The current state-of-the-art practical ORAM schemes are suitable only for somewhat small memories (Square-Root ORAM or Path ORAM).
This work presents a novel concretely efficient ORAM construction based on recent breakthroughs in asymptotic complexity of ORAM schemes (PanORAMa and OptORAMa). We bring these constructions to the realm of practically useful schemes by relaxing the restriction on constant local memory size.
Our design provides a factor of at least to improvement over an
implementation of the original Path ORAM for a set of reasonable memory sizes (e.g., 1GB, 1TB) and with the same local memory size. To our knowledge, this is the first practical implementation of an ORAM based on the full hierarchical ORAM framework. Prior to our work, the belief was that hierarchical ORAM-based constructions were inherently too expensive in practice. We implement our design and provide extensive evaluation and experimental results
Detect, Pack and Batch: Perfectly-Secure MPC with Linear Communication and Constant Expected Time
We prove that perfectly-secure optimally-resilient secure Multi-Party Computation (MPC) for a circuit with gates and depth can be obtained in communication complexity and expected time. For and , this is the first perfectly-secure optimal-resilient MPC protocol with linear communication complexity per gate and constant expected time complexity per layer.
Compared to state-of-the-art MPC protocols in the player elimination framework [Beerliova and Hirt TCC\u2708, and Goyal, Liu, and Song CRYPTO\u2719], for and , our results significantly improve the run time from to expected while keeping communication complexity at .
Compared to state-of-the-art MPC protocols that obtain an expected time complexity [Abraham, Asharov, and Yanai TCC\u2721], for , our results significantly improve the communication complexity from to while keeping the expected run time at .
One salient part of our technical contribution is centered around a new primitive we call detectable secret sharing . It is perfectly-hiding, weakly-binding, and has the property that either reconstruction succeeds or parties are (privately) detected. On the one hand, we show that detectable secret sharing is sufficiently powerful to generate multiplication triplets needed for MPC. On the other hand, we show how to share secrets via detectable secret sharing with communication complexity of just . When sharing secrets, the communication cost is amortized to just field elements per secret.
Our second technical contribution is a new Verifiable Secret Sharing protocol that can share secrets at just word complexity. When sharing secrets, the communication cost is amortized to just filed elements per secret. The best prior required communication per secret
Asymptotically Free Broadcast in Constant Expected Time via Packed VSS
Broadcast is an essential primitive for secure computation. We focus in this paper on optimal resilience (i.e., when the number of corrupted parties is less than a third of the computing parties ), and with no setup or cryptographic assumptions.
While broadcast with worst case rounds is impossible, it has been shown [Feldman and Micali STOC\u2788, Katz and Koo CRYPTO\u2706] how to construct protocols with expected constant number of rounds in the private channel model. However, those constructions have large communication complexity, specifically expected number of bits transmitted for broadcasting a message of length . This leads to a significant communication blowup in secure computation protocols in this setting.
In this paper, we substantially improve the communication complexity of broadcast in constant expected time. Specifically, the expected communication complexity of our protocol is . For messages of length , our broadcast has no asymptotic overhead (up to expectation), as each party has to send or receive bits. We also consider parallel broadcast, where parties wish to broadcast bit messages in parallel. Our protocol has no asymptotic overhead for , which is a common communication pattern in perfectly secure MPC protocols. For instance, it is common that all parties share their inputs simultaneously at the same round, and verifiable secret sharing protocols require the dealer to broadcast a total of bits.
As an independent interest, our broadcast is achieved by a packed verifiable secret sharing, a new notion that we introduce. We show a protocol that verifies secrets simultaneously with the same cost of verifying just a single secret. This improves by a factor of the state-of-the-art
Searchable Symmetric Encryption: Optimal Locality in Linear Space via Two-Dimensional Balanced Allocations
Searchable symmetric encryption (SSE) enables a client to store a database on an untrusted server while supporting keyword search in a secure manner. Despite the rapidly increasing interest in SSE technology, experiments indicate that the performance of the known schemes scales badly to large databases. Somewhat surprisingly, this is not due to their usage of cryptographic tools, but rather due to their poor locality (where locality is defined as the number of non-contiguous memory locations the server accesses with each query). The only known schemes that do not suffer from poor locality suffer either from an impractical space overhead or from an impractical read efficiency (where read efficiency is defined as the ratio between the number of bits the server reads with each query and the actual size of the answer).
We construct the first SSE schemes that simultaneously enjoy optimal locality, optimal space overhead, and nearly-optimal read efficiency. Specifically, for a database of size , under the modest assumption that no keyword appears in more than documents, we construct a scheme with read efficiency . This essentially matches the lower bound of Cash and Tessaro (EUROCRYPT \u2714) showing that any SSE scheme must be sub-optimal in either its locality, its space overhead, or its read efficiency. In addition, even without making any assumptions on the structure of the database, we construct a scheme with read efficiency .
Our schemes are obtained via a two-dimensional generalization of the classic balanced allocations (``balls and bins\u27\u27) problem that we put forward. We construct nearly-optimal two-dimensional balanced allocation schemes, and then combine their algorithmic structure with subtle cryptographic techniques